﻿using System;
using KWatkins.FluentMoqBuilder.Argument;

namespace KWatkins.FluentMoqBuilder
{
	internal static partial class Validate
	{
		internal static IUnsignedPreciseNumber<Byte> Argument(Byte argument, string parameterName)
		{
			return new ByteValidation(argument, parameterName);
		}
		internal static ISignedPreciseNumber<Decimal> Argument(Decimal argument, string parameterName)
		{
			return new DecimalValidation(argument, parameterName);
		}
		internal static ISignedPreciseNumber<Int16> Argument(Int16 argument, string parameterName)
		{
			return new Int16Validation(argument, parameterName);
		}
		internal static ISignedPreciseNumber<Int32> Argument(Int32 argument, string parameterName)
		{
			return new Int32Validation(argument, parameterName);
		}
		internal static ISignedPreciseNumber<Int64> Argument(Int64 argument, string parameterName)
		{
			return new Int64Validation(argument, parameterName);
		}
		internal static ISignedPreciseNumber<SByte> Argument(SByte argument, string parameterName)
		{
			return new SByteValidation(argument, parameterName);
		}
		internal static IUnsignedPreciseNumber<UInt16> Argument(UInt16 argument, string parameterName)
		{
			return new UInt16Validation(argument, parameterName);
		}
		internal static IUnsignedPreciseNumber<UInt32> Argument(UInt32 argument, string parameterName)
		{
			return new UInt32Validation(argument, parameterName);
		}
		internal static IUnsignedPreciseNumber<UInt64> Argument(UInt64 argument, string parameterName)
		{
			return new UInt64Validation(argument, parameterName);
		}
	}
}

namespace KWatkins.FluentMoqBuilder.Argument
{
	internal sealed class ByteValidation 
		: ArgumentValidation<Byte>, 
		IUnsignedPreciseNumber<Byte>
	{
		internal ByteValidation(Byte argument, string parameterName)
			: base(argument, parameterName)
		{
		}
		#region IUnsignedPreciseNumber Members
		IUnsignedPreciseNumber<Byte> IUnsignedPreciseNumber<Byte>.IsGreaterThan(Byte minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Byte> IUnsignedPreciseNumber<Byte>.IsGreaterThanOrEqualTo(Byte minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Byte> IUnsignedPreciseNumber<Byte>.IsLessThan(Byte maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Byte> IUnsignedPreciseNumber<Byte>.IsLessThanOrEqualTo(Byte maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		#endregion
	}
	
	internal sealed class DecimalValidation 
		: ArgumentValidation<Decimal>, 
		ISignedPreciseNumber<Decimal>,
		IUnsignedPreciseNumber<Decimal>
	{
		internal DecimalValidation(Decimal argument, string parameterName)
			: base(argument, parameterName)
		{
		}
		#region ISignedPreciseNumber Members
		ISignedPreciseNumber<Decimal> ISignedPreciseNumber<Decimal>.IsGreaterThan(Decimal minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Decimal> ISignedPreciseNumber<Decimal>.IsGreaterThanOrEqualTo(Decimal minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Decimal> ISignedPreciseNumber<Decimal>.IsLessThan(Decimal maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Decimal> ISignedPreciseNumber<Decimal>.IsLessThanOrEqualTo(Decimal maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		IUnsignedPreciseNumber<Decimal> ISignedPreciseNumber<Decimal>.IsPositive()
		{
			if (Argument <= 0m)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must be positive.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Decimal> ISignedPreciseNumber<Decimal>.IsNotPositive()
		{
			if (Argument > 0m)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must not be positive.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Decimal> ISignedPreciseNumber<Decimal>.IsNegative()
		{
			if (Argument >= 0m)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must be negative.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Decimal> ISignedPreciseNumber<Decimal>.IsNotNegative()
		{
			if (Argument < 0m)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must not be negative.");
			}
			return this;
		}
		#endregion
		#region IUnsignedPreciseNumber Members
		IUnsignedPreciseNumber<Decimal> IUnsignedPreciseNumber<Decimal>.IsGreaterThan(Decimal minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Decimal> IUnsignedPreciseNumber<Decimal>.IsGreaterThanOrEqualTo(Decimal minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Decimal> IUnsignedPreciseNumber<Decimal>.IsLessThan(Decimal maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Decimal> IUnsignedPreciseNumber<Decimal>.IsLessThanOrEqualTo(Decimal maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		#endregion
	}
	
	internal sealed class Int16Validation 
		: ArgumentValidation<Int16>, 
		ISignedPreciseNumber<Int16>,
		IUnsignedPreciseNumber<Int16>
	{
		internal Int16Validation(Int16 argument, string parameterName)
			: base(argument, parameterName)
		{
		}
		#region ISignedPreciseNumber Members
		ISignedPreciseNumber<Int16> ISignedPreciseNumber<Int16>.IsGreaterThan(Int16 minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Int16> ISignedPreciseNumber<Int16>.IsGreaterThanOrEqualTo(Int16 minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Int16> ISignedPreciseNumber<Int16>.IsLessThan(Int16 maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Int16> ISignedPreciseNumber<Int16>.IsLessThanOrEqualTo(Int16 maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		IUnsignedPreciseNumber<Int16> ISignedPreciseNumber<Int16>.IsPositive()
		{
			if (Argument <= 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must be positive.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Int16> ISignedPreciseNumber<Int16>.IsNotPositive()
		{
			if (Argument > 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must not be positive.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Int16> ISignedPreciseNumber<Int16>.IsNegative()
		{
			if (Argument >= 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must be negative.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Int16> ISignedPreciseNumber<Int16>.IsNotNegative()
		{
			if (Argument < 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must not be negative.");
			}
			return this;
		}
		#endregion
		#region IUnsignedPreciseNumber Members
		IUnsignedPreciseNumber<Int16> IUnsignedPreciseNumber<Int16>.IsGreaterThan(Int16 minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Int16> IUnsignedPreciseNumber<Int16>.IsGreaterThanOrEqualTo(Int16 minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Int16> IUnsignedPreciseNumber<Int16>.IsLessThan(Int16 maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Int16> IUnsignedPreciseNumber<Int16>.IsLessThanOrEqualTo(Int16 maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		#endregion
	}
	
	internal sealed class Int32Validation 
		: ArgumentValidation<Int32>, 
		ISignedPreciseNumber<Int32>,
		IUnsignedPreciseNumber<Int32>
	{
		internal Int32Validation(Int32 argument, string parameterName)
			: base(argument, parameterName)
		{
		}
		#region ISignedPreciseNumber Members
		ISignedPreciseNumber<Int32> ISignedPreciseNumber<Int32>.IsGreaterThan(Int32 minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Int32> ISignedPreciseNumber<Int32>.IsGreaterThanOrEqualTo(Int32 minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Int32> ISignedPreciseNumber<Int32>.IsLessThan(Int32 maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Int32> ISignedPreciseNumber<Int32>.IsLessThanOrEqualTo(Int32 maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		IUnsignedPreciseNumber<Int32> ISignedPreciseNumber<Int32>.IsPositive()
		{
			if (Argument <= 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must be positive.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Int32> ISignedPreciseNumber<Int32>.IsNotPositive()
		{
			if (Argument > 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must not be positive.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Int32> ISignedPreciseNumber<Int32>.IsNegative()
		{
			if (Argument >= 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must be negative.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Int32> ISignedPreciseNumber<Int32>.IsNotNegative()
		{
			if (Argument < 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must not be negative.");
			}
			return this;
		}
		#endregion
		#region IUnsignedPreciseNumber Members
		IUnsignedPreciseNumber<Int32> IUnsignedPreciseNumber<Int32>.IsGreaterThan(Int32 minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Int32> IUnsignedPreciseNumber<Int32>.IsGreaterThanOrEqualTo(Int32 minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Int32> IUnsignedPreciseNumber<Int32>.IsLessThan(Int32 maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Int32> IUnsignedPreciseNumber<Int32>.IsLessThanOrEqualTo(Int32 maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		#endregion
	}
	
	internal sealed class Int64Validation 
		: ArgumentValidation<Int64>, 
		ISignedPreciseNumber<Int64>,
		IUnsignedPreciseNumber<Int64>
	{
		internal Int64Validation(Int64 argument, string parameterName)
			: base(argument, parameterName)
		{
		}
		#region ISignedPreciseNumber Members
		ISignedPreciseNumber<Int64> ISignedPreciseNumber<Int64>.IsGreaterThan(Int64 minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Int64> ISignedPreciseNumber<Int64>.IsGreaterThanOrEqualTo(Int64 minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Int64> ISignedPreciseNumber<Int64>.IsLessThan(Int64 maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<Int64> ISignedPreciseNumber<Int64>.IsLessThanOrEqualTo(Int64 maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		IUnsignedPreciseNumber<Int64> ISignedPreciseNumber<Int64>.IsPositive()
		{
			if (Argument <= 0L)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must be positive.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Int64> ISignedPreciseNumber<Int64>.IsNotPositive()
		{
			if (Argument > 0L)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must not be positive.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Int64> ISignedPreciseNumber<Int64>.IsNegative()
		{
			if (Argument >= 0L)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must be negative.");
			}
			return this;
		}
		IUnsignedPreciseNumber<Int64> ISignedPreciseNumber<Int64>.IsNotNegative()
		{
			if (Argument < 0L)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must not be negative.");
			}
			return this;
		}
		#endregion
		#region IUnsignedPreciseNumber Members
		IUnsignedPreciseNumber<Int64> IUnsignedPreciseNumber<Int64>.IsGreaterThan(Int64 minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Int64> IUnsignedPreciseNumber<Int64>.IsGreaterThanOrEqualTo(Int64 minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Int64> IUnsignedPreciseNumber<Int64>.IsLessThan(Int64 maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<Int64> IUnsignedPreciseNumber<Int64>.IsLessThanOrEqualTo(Int64 maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		#endregion
	}
	
	internal sealed class SByteValidation 
		: ArgumentValidation<SByte>, 
		ISignedPreciseNumber<SByte>,
		IUnsignedPreciseNumber<SByte>
	{
		internal SByteValidation(SByte argument, string parameterName)
			: base(argument, parameterName)
		{
		}
		#region ISignedPreciseNumber Members
		ISignedPreciseNumber<SByte> ISignedPreciseNumber<SByte>.IsGreaterThan(SByte minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<SByte> ISignedPreciseNumber<SByte>.IsGreaterThanOrEqualTo(SByte minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<SByte> ISignedPreciseNumber<SByte>.IsLessThan(SByte maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		ISignedPreciseNumber<SByte> ISignedPreciseNumber<SByte>.IsLessThanOrEqualTo(SByte maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		IUnsignedPreciseNumber<SByte> ISignedPreciseNumber<SByte>.IsPositive()
		{
			if (Argument <= 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must be positive.");
			}
			return this;
		}
		IUnsignedPreciseNumber<SByte> ISignedPreciseNumber<SByte>.IsNotPositive()
		{
			if (Argument > 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must not be positive.");
			}
			return this;
		}
		IUnsignedPreciseNumber<SByte> ISignedPreciseNumber<SByte>.IsNegative()
		{
			if (Argument >= 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must be negative.");
			}
			return this;
		}
		IUnsignedPreciseNumber<SByte> ISignedPreciseNumber<SByte>.IsNotNegative()
		{
			if (Argument < 0)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, "Value must not be negative.");
			}
			return this;
		}
		#endregion
		#region IUnsignedPreciseNumber Members
		IUnsignedPreciseNumber<SByte> IUnsignedPreciseNumber<SByte>.IsGreaterThan(SByte minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<SByte> IUnsignedPreciseNumber<SByte>.IsGreaterThanOrEqualTo(SByte minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<SByte> IUnsignedPreciseNumber<SByte>.IsLessThan(SByte maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<SByte> IUnsignedPreciseNumber<SByte>.IsLessThanOrEqualTo(SByte maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		#endregion
	}
	
	internal sealed class UInt16Validation 
		: ArgumentValidation<UInt16>, 
		IUnsignedPreciseNumber<UInt16>
	{
		internal UInt16Validation(UInt16 argument, string parameterName)
			: base(argument, parameterName)
		{
		}
		#region IUnsignedPreciseNumber Members
		IUnsignedPreciseNumber<UInt16> IUnsignedPreciseNumber<UInt16>.IsGreaterThan(UInt16 minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<UInt16> IUnsignedPreciseNumber<UInt16>.IsGreaterThanOrEqualTo(UInt16 minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<UInt16> IUnsignedPreciseNumber<UInt16>.IsLessThan(UInt16 maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<UInt16> IUnsignedPreciseNumber<UInt16>.IsLessThanOrEqualTo(UInt16 maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		#endregion
	}
	
	internal sealed class UInt32Validation 
		: ArgumentValidation<UInt32>, 
		IUnsignedPreciseNumber<UInt32>
	{
		internal UInt32Validation(UInt32 argument, string parameterName)
			: base(argument, parameterName)
		{
		}
		#region IUnsignedPreciseNumber Members
		IUnsignedPreciseNumber<UInt32> IUnsignedPreciseNumber<UInt32>.IsGreaterThan(UInt32 minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<UInt32> IUnsignedPreciseNumber<UInt32>.IsGreaterThanOrEqualTo(UInt32 minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<UInt32> IUnsignedPreciseNumber<UInt32>.IsLessThan(UInt32 maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<UInt32> IUnsignedPreciseNumber<UInt32>.IsLessThanOrEqualTo(UInt32 maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		#endregion
	}
	
	internal sealed class UInt64Validation 
		: ArgumentValidation<UInt64>, 
		IUnsignedPreciseNumber<UInt64>
	{
		internal UInt64Validation(UInt64 argument, string parameterName)
			: base(argument, parameterName)
		{
		}
		#region IUnsignedPreciseNumber Members
		IUnsignedPreciseNumber<UInt64> IUnsignedPreciseNumber<UInt64>.IsGreaterThan(UInt64 minimum)
		{
			if (Argument <= minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<UInt64> IUnsignedPreciseNumber<UInt64>.IsGreaterThanOrEqualTo(UInt64 minimum)
		{
			if (Argument < minimum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be greater than or equal to ", minimum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<UInt64> IUnsignedPreciseNumber<UInt64>.IsLessThan(UInt64 maximum)
		{
			if (Argument >= maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than ", maximum, "."));
			}
			return this;
		}

		IUnsignedPreciseNumber<UInt64> IUnsignedPreciseNumber<UInt64>.IsLessThanOrEqualTo(UInt64 maximum)
		{
			if (Argument > maximum)
			{
				throw new ArgumentOutOfRangeException(ParameterName, Argument, string.Concat("Value must be less than or equal to ", maximum, "."));
			}
			return this;
		}
		#endregion
	}
	
}
